import Taro from '@tarojs/taro'

// 请求基础配置
const BASE_URL = process.env.TARO_APP_API_BASE_URL || 'http://localhost:8080'
const TIMEOUT = 10000

// 请求拦截器
const requestInterceptor = (chain) => {
  const requestParams = chain.requestParams
  const { method, data, url } = requestParams
  console.log("请求地址："+process.env.TARO_APP_API_BASE_URL)
  console.log('请求拦截器 - 原始URL:', url)
  console.log('请求拦截器 - requestParams:', requestParams)

  console.log(`HTTP ${method || 'GET'} --> ${url}`)
  console.log('请求参数：', data)

  // 添加token
  const token = Taro.getStorageSync('token')
  if (token) {
    requestParams.header = {
      ...requestParams.header,
      'Authorization': `Bearer ${token}`
    }
  }

  // 添加通用header
  requestParams.header = {
    'Content-Type': 'application/json',
    ...requestParams.header
  }

  console.log('请求拦截器 - 返回前的requestParams:', requestParams)
  console.log('请求拦截器 - 返回前的URL:', requestParams.url)
  return chain.proceed(requestParams)
}

// 响应拦截器
const responseInterceptor = (chain) => {
  console.log('响应拦截器被调用')
  console.log('响应拦截器 - chain对象:', chain)
  console.log('响应拦截器 - requestParams:', chain.requestParams)
  console.log('响应拦截器 - URL:', chain.requestParams?.url)
  
  // 保存原始的requestParams
  const originalRequestParams = { ...chain.requestParams }
  console.log('响应拦截器 - 保存的原始requestParams:', originalRequestParams)
  
  console.log('响应拦截器 - 准备调用chain.proceed()')
  const proceedPromise = chain.proceed(originalRequestParams)
  console.log('响应拦截器 - chain.proceed()已调用，返回Promise:', proceedPromise)
  return proceedPromise.then(res => {
    console.log('响应结果：', res)
    console.log('响应状态码：', res.statusCode)
    console.log('响应数据：', res.data)
    
    const { statusCode, data } = res
    
    // HTTP状态码检查
    if (statusCode >= 200 && statusCode < 300) {
      // 业务状态码检查
      if (data.code === 200) {
        return data
      } else if (data.code === 401) {
        // token过期，清除本地存储并跳转登录
        Taro.removeStorageSync('token')
        Taro.removeStorageSync('userInfo')
        Taro.showToast({
          title: '登录已过期，请重新登录',
          icon: 'none'
        })
        // 跳转到登录页
        setTimeout(() => {
          Taro.reLaunch({
            url: '/pages/login/index'
          })
        }, 1500)
        return Promise.reject(data)
      } else {
        // 其他业务错误
        Taro.showToast({
          title: data.msg || '请求失败',
          icon: 'none'
        })
        return Promise.reject(data)
      }
    } else {
      // HTTP错误
      Taro.showToast({
        title: '网络请求失败',
        icon: 'none'
      })
      return Promise.reject(res)
    }
  }).catch(error => {
    console.error('请求错误：', error)
    console.log('错误发生时的chain对象:', chain)
    console.log('错误发生时的requestParams:', chain.requestParams)
    console.log('错误发生时的URL:', chain.requestParams?.url)
    Taro.showToast({
      title: '网络连接失败',
      icon: 'none'
    })
    return Promise.reject(error)
  })
}

// 添加拦截器
Taro.addInterceptor(requestInterceptor)
Taro.addInterceptor(responseInterceptor)

/**
 * 封装请求方法
 */
class Request {
  /**
   * GET请求
   * @param {string} url 请求地址
   * @param {object} params 请求参数
   * @param {object} options 其他配置
   */
  static get(url, params = {}, options = {}) {
    const fullUrl = BASE_URL + url
    console.log('GET请求 - BASE_URL:', BASE_URL)
    console.log('GET请求 - url参数:', url)
    console.log('GET请求 - 完整URL:', fullUrl)
    return Taro.request({
      url: fullUrl,
      method: 'GET',
      data: params,
      timeout: TIMEOUT,
      ...options
    })
  }

  /**
   * POST请求
   * @param {string} url 请求地址
   * @param {object} data 请求数据
   * @param {object} options 其他配置
   */
  static post(url, data = {}, options = {}) {
    const fullUrl = BASE_URL + url
    console.log('POST请求 - BASE_URL:', BASE_URL)
    console.log('POST请求 - url参数:', url)
    console.log('POST请求 - 完整URL:', fullUrl)
    return Taro.request({
      url: fullUrl,
      method: 'POST',
      data,
      timeout: TIMEOUT,
      ...options
    })
  }

  /**
   * PUT请求
   * @param {string} url 请求地址
   * @param {object} data 请求数据
   * @param {object} options 其他配置
   */
  static put(url, data = {}, options = {}) {
    return Taro.request({
      url: BASE_URL + url,
      method: 'PUT',
      data,
      timeout: TIMEOUT,
      ...options
    })
  }

  /**
   * DELETE请求
   * @param {string} url 请求地址
   * @param {object} params 请求参数
   * @param {object} options 其他配置
   */
  static delete(url, params = {}, options = {}) {
    return Taro.request({
      url: BASE_URL + url,
      method: 'DELETE',
      data: params,
      timeout: TIMEOUT,
      ...options
    })
  }

  /**
   * 文件上传
   * @param {string} url 上传地址
   * @param {string} filePath 文件路径
   * @param {string} name 文件对应的key
   * @param {object} formData 其他表单数据
   */
  static upload(url, filePath, name = 'file', formData = {}) {
    const token = Taro.getStorageSync('token')
    return Taro.uploadFile({
      url: BASE_URL + url,
      filePath,
      name,
      formData,
      header: {
        'Authorization': token ? `Bearer ${token}` : ''
      }
    })
  }
}

export default Request